import { ElMessage } from 'element-plus';
// 后端API地址
//const API_BASE_URL = 'http://localhost:3000'; // 开发环境
const API_BASE_URL = 'https://api.rsjsq.aiqji.com'; // 生产环境，自己部署的后端服务地址
// 添加一个简单的锁机制来防止并发请求
let isRequestInProgress = false;
/**
 * 生成人生阶段描述
 * @param {Object} params - 包含年龄、阶段等信息的参数
 * @returns {Promise<string>} - 返回生成的描述文本
 */
export async function generateLifeDescription(params, onProgress = () => { }) {
  // 如果已经有请求在进行中，拒绝新的请求
  if (isRequestInProgress) {
    ElMessage.warning('已有一个请求正在处理中，请等待当前请求完成');
    return Promise.reject(new Error('请求被拒绝: 已有进行中的请求'));
  }
  // 创建一个队列系统来确保按顺序更新
  let updateQueue = Promise.resolve();
  const queuedUpdate = (content, isFirst = false, reasoningContent = '') => {
    console.log(`[队列] 加入新更新，内容长度: ${content.length}，思维链长度: ${reasoningContent.length}，首次: ${isFirst}`);
    // 记录当前内容的最后20个字符，用于追踪
    const lastChars = content.length > 20 ? content.substring(content.length - 20) : content;
    console.log(`[队列] 当前内容结尾: "${lastChars}"`);
    updateQueue = updateQueue.then(() => new Promise((resolve) => {
      console.log(`[队列] 执行更新，内容长度: ${content.length}`);
      onProgress(content, isFirst, reasoningContent);
      // 添加延时确保UI有时间更新
      setTimeout(() => {
        console.log(`[队列] 更新完成`);
        resolve();
      }, 10);
    }));
    return updateQueue;
  };
  // 设置锁定状态
  isRequestInProgress = true;
  let content = '';
  let reasoningContent = ''; // 新增：用于存储思维链内容
  let isFirstChunk = true;
  const startTime = Date.now();
  console.log('开始生成描述请求:', startTime);
  try {
    // 发送请求到我们的后端服务
    const response = await fetch(`${API_BASE_URL}/api/generate-description`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-Request-ID': Date.now().toString() // 添加请求ID帮助后端识别
      },
      body: JSON.stringify(params)
    });
    if (!response.ok) {
      const errorData = await response.json().catch(() => ({}));
      throw new Error(`API请求失败: ${errorData.error || response.statusText}`);
    }
    console.log('收到响应, 状态:', response.status, '类型:', response.headers.get('Content-Type'));
    // 创建本地模拟流式输出的控制变量
    let useLocalSimulation = false;
    let fullContent = '';
    let fullReasoningContent = ''; // 新增：完整的思维链内容
    let simulationTimer = null;
    // 处理流式响应
    const reader = response.body.getReader();
    const decoder = new TextDecoder();
    let buffer = '';
    let chunkCounter = 0;
    let lastUpdateTime = Date.now();
    console.log('准备读取流式数据');
    // 流式处理循环
    while (true) {
      const { done, value } = await reader.read();
      if (done) {
        console.log(`流式读取完成，共收到${chunkCounter}个数据块`);
        break;
      }
      chunkCounter++;
      const chunk = decoder.decode(value);
      console.log(`收到数据块#${chunkCounter}, 大小: ${value.length}字节`);
      buffer += chunk;
      // 处理可能的多行数据
      const lines = buffer.split('\n\n');
      buffer = lines.pop() || '';
      for (const line of lines) {
        if (!line.trim()) continue;
        if (!line.startsWith('data:')) continue;
        const dataContent = line.substring(5).trim();
        if (dataContent === '[DONE]') {
          console.log('收到流结束标记 [DONE]');
          continue;
        }
        try {
          // 解析JSON数据
          const data = JSON.parse(dataContent);
          // 处理包含chunk字段的响应
          if (data.chunk) {
            console.log(`解析成功，收到文本块: "${data.chunk.substring(0, 20)}${data.chunk.length > 20 ? '...' : ''}"`);
            // 保存完整内容，用于可能的本地模拟
            fullContent += data.chunk;
            // 如果是第一次接收内容，添加缩进
            if (content === '') {
              content = typeof data.chunk === 'string' && data.chunk.startsWith('　　')
                ? data.chunk
                : '　　' + data.chunk;
            } else {
              content += data.chunk;
            }
            // 添加模拟延迟让流式效果更明显
            const now = Date.now();
            const timeSinceLastUpdate = now - lastUpdateTime;
            // 如果数据块之间时间间隔太短，添加额外延迟
            if (timeSinceLastUpdate < 30 && !isFirstChunk) {
              await new Promise(resolve => setTimeout(resolve, 30 - timeSinceLastUpdate));
              console.log('添加人为延迟，增强流式效果');
            }
            lastUpdateTime = Date.now();
            // 通知前端更新UI - 使用队列确保顺序，同时传递思维链内容
            if (isFirstChunk) {
              isFirstChunk = false;
              console.log('调用首次进度回调');
              await queuedUpdate(content, true, reasoningContent);
            } else {
              console.log('调用进度回调，当前内容长度:', content.length);
              await queuedUpdate(content, false, reasoningContent);
            }
          }
          // 确保在API.js处理思维链的部分正确实现：
          // 新增: 处理包含reasoning_chunk字段的响应
          else if (data.reasoning_chunk) {
            console.log(`收到思维链内容: "${data.reasoning_chunk.substring(0, 20)}${data.reasoning_chunk.length > 20 ? '...' : ''}"`);
            // 保存思维链完整内容
            fullReasoningContent += data.reasoning_chunk;
            // 添加到思维链内容
            if (reasoningContent === '') {
              reasoningContent = data.reasoning_chunk;
            } else {
              reasoningContent += data.reasoning_chunk;
            }
            // 更新UI，保持当前内容不变，只更新思维链
            await queuedUpdate(content, false, reasoningContent);
          }
          // 兼容处理DeepSeek原始格式
          else if (data.choices && data.choices[0] && data.choices[0].delta) {
            const delta = data.choices[0].delta;
            // 处理常规content
            if (delta.content) {
              const chunkContent = delta.content;
              console.log(`解析成功，收到DeepSeek内容: "${chunkContent.substring(0, 20)}${chunkContent.length > 20 ? '...' : ''}"`);
              // 保存完整内容
              fullContent += chunkContent;
              if (content === '') {
                content = chunkContent.startsWith('　　') ? chunkContent : '　　' + chunkContent;
              } else {
                content += chunkContent;
              }
              // 同样添加延迟
              const now = Date.now();
              const timeSinceLastUpdate = now - lastUpdateTime;
              if (timeSinceLastUpdate < 50 && !isFirstChunk) {
                await new Promise(resolve => setTimeout(resolve, 50 - timeSinceLastUpdate));
              }
              lastUpdateTime = Date.now();
              // 使用队列系统更新UI，传递思维链内容
              if (isFirstChunk) {
                isFirstChunk = false;
                await queuedUpdate(content, true, reasoningContent);
              } else {
                await queuedUpdate(content, false, reasoningContent);
              }
            }
            // 处理reasoning_content
            if (delta.reasoning_content) {
              const reasoningChunk = delta.reasoning_content;
              console.log(`收到原始DeepSeek思维链: "${reasoningChunk.substring(0, 20)}..."`);
              // 保存完整思维链内容
              fullReasoningContent += reasoningChunk;
              if (reasoningContent === '') {
                reasoningContent = reasoningChunk;
              } else {
                reasoningContent += reasoningChunk;
              }
              // 更新UI，只更新思维链
              await queuedUpdate(content, false, reasoningContent);
            }
          }
        } catch (e) {
          console.warn('解析流式数据出错:', e);
          console.warn('原始数据:', line.substring(0, 100));
        }
      }
    }
    // 如果经过处理后发现内容很短但收到的块数很少，可能流式失效
    if (chunkCounter <= 3 && content.length > 100) {
      console.log('检测到可能的流式输出失败，激活本地模拟...');
      // 激活本地模拟流式
      useLocalSimulation = true;
    }
    // 添加本地模拟流式输出逻辑
    if (useLocalSimulation && fullContent.length > 0) {
      console.log('开始本地模拟流式输出');
      // 清空已有内容，重新开始
      content = '';
      reasoningContent = ''; // 重置思维链内容
      isFirstChunk = true;
      // 将完整文本分割成小块
      const simulateChunks = [];
      let totalLength = fullContent.length;
      let startPos = 0;
      // 将内容分成20-30个字符的小块
      while (startPos < totalLength) {
        const chunkSize = Math.floor(Math.random() * 10) + 20; // 20-30字符
        simulateChunks.push(fullContent.substring(startPos, Math.min(startPos + chunkSize, totalLength)));
        startPos += chunkSize;
      }
      console.log(`本地模拟：将文本分成了${simulateChunks.length}个小块`);
      // 生成一些模拟的思维链内容
      const simulateReasoningChunks = [
        "我需要描述这个人生阶段的特点...",
        "思考这个年龄段可能经历的事情...",
        "分析面临的机遇与挑战...",
        "构思一些积极的建议和理解...",
        "保持文字的温暖和哲理性..."
      ];
      // 改用async函数顺序执行，替代setInterval
      const simulateStream = async () => {
        for (let index = 0; index < simulateChunks.length; index++) {
          const chunk = simulateChunks[index];
          console.log(`本地模拟：发送块 ${index + 1}/${simulateChunks.length}`);
          if (content === '') {
            content = '　　' + chunk;
          } else {
            content += chunk;
          }
          // 每到一定数量的块，添加一条思维链内容
          if (index % Math.floor(simulateChunks.length / simulateReasoningChunks.length) === 0) {
            const reasoningIndex = Math.floor(index / (simulateChunks.length / simulateReasoningChunks.length));
            if (reasoningIndex < simulateReasoningChunks.length) {
              if (reasoningContent === '') {
                reasoningContent = simulateReasoningChunks[reasoningIndex];
              } else {
                reasoningContent += "\n" + simulateReasoningChunks[reasoningIndex];
              }
              console.log(`本地模拟：添加思维链 ${reasoningIndex + 1}`);
            }
          }
          if (index === 0) {
            isFirstChunk = false;
            await queuedUpdate(content, true, reasoningContent);
          } else {
            await queuedUpdate(content, false, reasoningContent);
          }
          // 每个块之间添加延迟
          await new Promise(resolve => setTimeout(resolve, 100));
        }
        console.log('本地模拟流式输出完成');
      };
      // 执行模拟流式输出
      await simulateStream();
    }
    const elapsed = Date.now() - startTime;
    console.log(`流式响应处理完成，用时：${elapsed}ms`);
    return {
      content: content,
      reasoningContent: reasoningContent
    };
  } catch (error) {
    console.error('生成描述失败:', error);
    ElMessage.error(`生成描述失败: ${error.message}`);
    // 使用备用描述
    console.log('使用备用描述');
    const backupContent = getBackupDescription(params.stage);
    // 为备用描述也提供模拟流式效果
    const simulateBackup = async () => {
      // 将备用内容分成小块
      const chunks = [];
      let pos = 0;
      while (pos < backupContent.length) {
        const chunkSize = Math.floor(Math.random() * 5) + 3; // 3-8字符
        chunks.push(backupContent.substring(pos, Math.min(pos + chunkSize, backupContent.length)));
        pos += chunkSize;
      }
      // 生成模拟思维链
      const backupReasoning = [
        "这是备用内容的思维过程...",
        "正在分析这个年龄段的特点...",
        "考虑适合的表达方式和建议..."
      ];
      let backupReasoningContent = '';
      // 分批发送以模拟流式
      console.log(`模拟备用内容流式输出，分成${chunks.length}块`);
      let localContent = '';
      // 使用for循环顺序执行，确保顺序正确
      for (let i = 0; i < chunks.length; i++) {
        if (localContent === '') {
          localContent = '　　' + chunks[i];
        } else {
          localContent += chunks[i];
        }
        // 模拟思维链内容
        if (i % Math.floor(chunks.length / backupReasoning.length) === 0) {
          const reasoningIndex = Math.floor(i / (chunks.length / backupReasoning.length));
          if (reasoningIndex < backupReasoning.length) {
            if (backupReasoningContent === '') {
              backupReasoningContent = backupReasoning[reasoningIndex];
            } else {
              backupReasoningContent += "\n" + backupReasoning[reasoningIndex];
            }
          }
        }
        if (i === 0) {
          await queuedUpdate(localContent, true, backupReasoningContent);
        } else {
          await queuedUpdate(localContent, false, backupReasoningContent);
        }
        // 每块之间添加随机延迟
        await new Promise(r => setTimeout(r, Math.floor(Math.random() * 60) + 60));
      }
    };
    // 执行备用内容的模拟流式
    await simulateBackup();
    return {
      content: backupContent,
      reasoningContent: "这是备用内容，没有真实的思维链过程。"
    };
  } finally {
    // 无论成功或失败，最后都要解锁
    isRequestInProgress = false;
  }
}
/**
 * 获取一言
 * @returns {Promise<Object>} 返回一言内容和作者
 */
export async function fetchRandomQuote() {
  try {
    console.log('请求一言接口');
    const cacheBuster = Date.now(); // 防止缓存
    const response = await fetch(`${API_BASE_URL}/api/yiyan?_=${cacheBuster}`, {
      method: 'GET',
      headers: { 'Content-Type': 'application/json' }
    });
    console.log('响应结果:', response);
    if (!response.ok) {
      throw new Error(`API请求失败: ${response.status}`);
    }
    const data = await response.json();
    console.log('一言接口返回:', data);
    // 处理返回数据
    if (data && data.code === 200) {
      // 确保msg字段有值
      const quoteText = data.msg || '';
      // 检查是否已经有作者信息，寻找分隔符"——"
      const parts = quoteText.split('——');
      if (parts.length >= 2) {
        // 如果分成了多部分，最后一部分是作者，前面部分是内容
        const author = parts.pop().trim();
        const text = parts.join('——').trim(); // 重新组合，以防内容中也包含分隔符
        return {
          text: text,
          author: author || '佚名' // 如果作者为空，显示佚名
        };
      } else {
        // 如果没有明确的作者信息，将整个文本作为内容，作者标为"佚名"
        return {
          text: quoteText.trim(),
          author: '佚名'
        };
      }
    }
    throw new Error('接口返回数据格式不正确');
  } catch (error) {
    console.error('获取一言失败:', error);
    // 返回备用数据
    return {
      text: '人生如棋，落子无悔',
      author: '佚名'
    };
  }
}
/**
 * 测试后端连接
 * @returns {Promise<boolean>} 是否连接成功
 */
export async function testBackendConnection() {
  try {
    const response = await fetch(`${API_BASE_URL}/api/test`, {
      method: 'GET',
      headers: {
        'Content-Type': 'application/json'
      }
    });

    if (!response.ok) {
      return false;
    }
    const data = await response.json();
    return data.status === 'ok';
  } catch (error) {
    console.error('测试后端连接失败:', error);
    return false;
  }
}
// 备用描述函数
function getBackupDescription(stage) {
  const descriptions = {
    '婴儿期': '　　这是人生最初的启程，一个充满好奇和探索的时期。在这个阶段，每一天都在学习最基本的生存技能，从咿呀学语到蹒跚学步，每一个进步都令人欣喜。世界对你来说是全新的画布，而你正在用自己的方式描绘第一笔。父母的爱是你的港湾，他们的每一个微笑和鼓励都是你勇敢探索的动力。享受这纯真无邪的美好时光，因为它将成为你人生旅程中最珍贵的开端。🌱',
    '幼儿期': '　　想象力和创造力开始绽放的黄金时期。你的世界充满了无限可能，每一天都是新奇冒险的开始。通过游戏和互动，你不仅认识这个世界，还在建立最初的社交关系，形成基本的性格特征。这个时期的经历会深刻影响你未来的发展方向。父母和教育者的引导尤为重要，既要给予足够的自由空间发展创造力，又要适当设立界限培养规则意识。珍惜这段时光，它是构建未来的重要基石。✨',
    '童年期': '　　求知欲旺盛的美好时光，这是你系统接受教育的开始，也是培养兴趣爱好的关键期。友谊在这个阶段变得格外珍贵，同伴之间的互动教会你分享、合作与理解。纯真的快乐和无忧无虑是这个阶段的特权，同时也在为未来的成长打下重要基础。好奇心是你最大的财富，保护它、培养它，让它引导你探索这个奇妙的世界。家长和老师的鼓励与引导，将帮助你建立自信和良好的学习习惯。🌈',
    '青少年期': '　　充满活力与梦想的转变期，你的身心正在快速发展，观念和价值观开始形成。这是开始思考人生方向，建立自我认知的重要阶段，同时也面临着升学和未来规划的挑战。叛逆与困惑或许会时常造访，但这恰是你寻找自我、确立独立思想的必经之路。友谊和同辈关系在此时变得尤为重要，它们塑造着你的社交视野。不要害怕犯错，因为每一次跌倒都是成长的契机。相信自己，你正在成为独一无二的存在。🌟',
    '成年早期': '　　迈入独立生活的重要阶段，你或许正面临学业深造或职业选择的关键决策。这是建立社会关系网络、逐步承担责任、规划人生方向的时期。初入社会的挑战与机遇并存，每一次尝试都在丰富你的阅历。不要对自己期望过高，成长需要时间，成功需要积累。保持开放的心态去学习和适应，同时也要倾听内心的声音，找到真正适合自己的道路。记住，这是探索的时期，尝试不同可能性是完全正常的。💫',
    '青年期': '　　事业发展的黄金时期，你在工作中积累经验，专业能力日益成熟。同时，这也可能是你开始组建家庭的阶段，学习平衡事业与生活的艺术。责任感和使命感逐渐增强，你的决策开始影响更多人的生活。面对压力和挑战时，学会自我调适和寻求支持。不要忽视个人成长和情感需求，工作成就之外，内心的富足同样重要。努力工作，但也请记得，生活的意义不仅在于成就，还在于那些与所爱之人共度的温暖时光。🌻',
    '中年早期': '　　事业和家庭逐渐稳定的时期，你在工作中可能已达到较高水平，同时面临家庭教育等多重责任。这是人生的重要承上启下阶段，既要照顾上一代，又要培养下一代。在享受成就的同时，也可能开始思考人生的意义和价值。保持学习的热情和开放的心态，不断更新自己的知识和技能。照顾好自己的身心健康，为长远的人生做好准备。学会适时放慢脚步，欣赏沿途的风景，体会生活的细腻与丰富。🍁',
    '中年期': '　　经验和智慧日益丰富的阶段，你可能在工作中处于领导岗位，拥有丰富的人生阅历和专业技能。家庭生活趋于成熟，与伴侣的关系更加稳定深厚。这是开始思考人生更深层意义的时期，价值观可能会有所调整和升华。身体状况的变化提醒你更加关注健康，建立良好的生活习惯。不妨尝试一些新的兴趣爱好，发掘自己未曾展现的才能。传递经验给年轻一代，帮助他们少走弯路，也能带给你成就感和意义感。🌲',
    '老年期': '　　收获人生智慧的时期，你可以放慢脚步享受生活，陪伴家人，培养兴趣爱好。这是回顾、总结和回馈的阶段，你的经验和智慧是年轻一代的宝贵财富。保持积极的心态和健康的生活方式尤为重要，它们能帮助你更好地享受这段时光。与家人朋友保持紧密联系，分享你的故事和智慧。尝试新事物，保持好奇心和学习欲望，年龄从不是障碍。每一天都是礼物，怀着感恩之心，平静安详地享受人生的这一阶段。🌅'
  };
  return descriptions[stage] || '　　这是人生的重要阶段，每个时期都有其独特的意义和价值。经历是我们成长的养分，挑战是我们前进的动力。无论这一阶段带来什么，都以开放的心态接纳，从中汲取智慧与力量。生命的旅程充满惊喜，愿你在每个阶段都能找到属于自己的意义与美好。✨';
}